namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// A specialized panel intended for use as an application window. Windows are floated, {@link #resizable}, and
	/// {@link #draggable} by default. Windows can be {@link #maximizable maximized} to fill the viewport,
	/// restored to their prior size, and can be {@link #minimize}d.  Windows can also be linked to a {@link Ext.WindowGroup} or managed by the {@link Ext.WindowMgr} to provide
	/// grouping, activation, to front, to back and other application-specific behavior.  By default, Windows will be rendered to document.body. To {@link #constrain} a Window to another element
	/// specify {@link Ext.Component#renderTo renderTo}.  Note: By default, the {@link #closable close} header tool destroys the Window resulting in
	/// destruction of any child Components. This makes the Window object, and all its descendants unusable. To enable
	/// re-use of a Window, use {@link #closeAction closeAction: &apos;hide&apos;}.
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;A specialized panel intended for use as an application window. Windows are floated, {@link #resizable}, and
	/// {@link #draggable} by default. Windows can be {@link #maximizable maximized} to fill the viewport,
	/// restored to their prior size, and can be {@link #minimize}d.&lt;/p&gt;
	/// &lt;p&gt;Windows can also be linked to a {@link Ext.WindowGroup} or managed by the {@link Ext.WindowMgr} to provide
	/// grouping, activation, to front, to back and other application-specific behavior.&lt;/p&gt;
	/// &lt;p&gt;By default, Windows will be rendered to document.body. To {@link #constrain} a Window to another element
	/// specify {@link Ext.Component#renderTo renderTo}.&lt;/p&gt;
	/// &lt;p&gt;&lt;b&gt;Note:&lt;/b&gt; By default, the &lt;code&gt;{@link #closable close}&lt;/code&gt; header tool &lt;i&gt;destroys&lt;/i&gt; the Window resulting in
	/// destruction of any child Components. This makes the Window object, and all its descendants &lt;b&gt;unusable&lt;/b&gt;. To enable
	/// re-use of a Window, use &lt;b&gt;&lt;code&gt;{@link #closeAction closeAction: &apos;hide&apos;}&lt;/code&gt;&lt;/b&gt;.&lt;/p&gt;
	/// </htmlSummary>
	/// <definedin>src\widgets\Window.js</definedin>
	[ScriptName("Window")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class Window : ext.Panel
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		/// <param name="config">The config object</param>
		public Window(ext.Window_Configuration config)
		{
		}
		
		/// <summary>Constructor</summary>
		public Window()
		{
		}
		#endregion
		
		#region Fields
		/// <summary>
		/// The X position of the left edge of the window on initial showing. Defaults to centering the Window within
		/// the width of the Window&apos;s container {@link Ext.Element Element) (The Element that the Window is rendered to).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("x")]
		public System.Number X;
		
		/// <summary>
		/// The Y position of the top edge of the window on initial showing. Defaults to centering the Window within
		/// the height of the Window&apos;s container {@link Ext.Element Element) (The Element that the Window is rendered to).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("y")]
		public System.Number Y;
		
		/// <summary>
		/// True to make the window modal and mask everything behind it when displayed, false to display it without
		/// restricting access to other UI elements (defaults to false).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("modal")]
		public bool Modal;
		
		/// <summary>Id or element from which the window should animate while opening (defaults to null with no animation).</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("animateTarget")]
		public ext.auto.System_String_Or_ext_Element AnimateTarget;
		
		/// <summary>A valid {@link Ext.Resizable} handles config string (defaults to &apos;all&apos;). Only applies when resizable = true.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("resizeHandles")]
		public string ResizeHandles;
		
		/// <summary>A reference to the WindowGroup that should manage this window (defaults to {@link Ext.WindowMgr}).</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("manager")]
		public ext.WindowGroup Manager;
		
		/// <summary>Specifies a Component to receive focus when this Window is focussed.  This may be one of:    The index of a footer Button.  The id of a Component.  A Component.</summary>
		/// <htmlSummary>
		/// &lt;p&gt;Specifies a Component to receive focus when this Window is focussed.&lt;/p&gt;
		/// &lt;p&gt;This may be one of:&lt;/p&gt;&lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;The index of a footer Button.&lt;/li&gt;
		/// &lt;li&gt;The id of a Component.&lt;/li&gt;
		/// &lt;li&gt;A Component.&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("defaultButton")]
		public ext.auto.System_String_Or_System_Number_Or_ext_Component DefaultButton;
		
		/// <summary>
		/// Allows override of the built-in processing for the escape key. Default action
		/// is to close the Window (performing whatever action is specified in {@link #closeAction}.
		/// To prevent the Window closing when the escape key is pressed, specify this as
		/// Ext.emptyFn (See {@link Ext#emptyFn}).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("onEsc")]
		public System.Delegate OnEsc;
		
		/// <summary>
		/// True to render the window collapsed, false to render it expanded (defaults to false). Note that if
		/// {@link #expandOnShow} is true (the default) it will override the collapsed config and the window
		/// will always be expanded when shown.
		/// </summary>
		/// <htmlSummary>
		/// True to render the window collapsed, false to render it expanded (defaults to false). Note that if
		/// {@link #expandOnShow} is true (the default) it will override the &lt;tt&gt;collapsed&lt;/tt&gt; config and the window
		/// will always be expanded when shown.
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("collapsed")]
		public bool Collapsed;
		
		/// <summary>True to initially display the window in a maximized state. (Defaults to false).</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("maximized")]
		public bool Maximized;
		
		/// <summary>The base CSS class to apply to this panel&apos;s element (defaults to &apos;x-window&apos;).</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("baseCls")]
		public string BaseCls;
		
		/// <summary>True to allow user resizing at each edge and corner of the window, false to disable resizing (defaults to true).</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("resizable")]
		public bool Resizable;
		
		/// <summary>
		/// True to allow the window to be dragged by the header bar, false to disable dragging (defaults to true). Note
		/// that by default the window will be centered in the viewport, so if dragging is disabled the window may need
		/// to be positioned programmatically after render (e.g., myWindow.setPosition(100, 100);).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("draggable")]
		public bool Draggable;
		
		/// <summary>
		/// True to display the &apos;close&apos; tool button and allow the user to close the window, false to
		/// hide the button and disallow closing the window (defaults to true).  By default, when close is requested by either clicking the close button in the header
		/// or pressing ESC when the Window has focus, the {@link #close} method will be called. This
		/// will {@link Ext.Component#destroy destroy} the Window and its content meaning that
		/// it may not be reused.  To make closing a Window hide the Window so that it may be reused, set
		/// {@link #closeAction} to &apos;hide&apos;.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;True to display the &apos;close&apos; tool button and allow the user to close the window, false to
		/// hide the button and disallow closing the window (defaults to true).&lt;/p&gt;
		/// &lt;p&gt;By default, when close is requested by either clicking the close button in the header
		/// or pressing ESC when the Window has focus, the {@link #close} method will be called. This
		/// will &lt;i&gt;{@link Ext.Component#destroy destroy}&lt;/i&gt; the Window and its content meaning that
		/// it may not be reused.&lt;/p&gt;
		/// &lt;p&gt;To make closing a Window &lt;i&gt;hide&lt;/i&gt; the Window so that it may be reused, set
		/// {@link #closeAction} to &apos;hide&apos;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("closable")]
		public bool Closable;
		
		/// <summary>
		/// The action to take when the close header tool is clicked:
		///   &apos;{@link #close}&apos; : Default 
		/// {@link #close remove} the window from the DOM and {@link Ext.Component#destroy destroy}
		/// it and all descendant Components. The window will not be available to be
		/// redisplayed via the {@link #show} method.
		///   &apos;{@link #hide}&apos; :  
		/// {@link #hide} the window by setting visibility to hidden and applying negative offsets.
		/// The window will be available to be redisplayed via the {@link #show} method.
		///     Note: This setting does not affect the {@link #close} method
		/// which will always {@link Ext.Component#destroy destroy} the window. To
		/// programatically hide a window, call {@link #hide}.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;The action to take when the close header tool is clicked:
		/// &lt;div class=&quot;mdetail-params&quot;&gt;&lt;ul&gt;
		/// &lt;li&gt;&lt;b&gt;&lt;code&gt;&apos;{@link #close}&apos;&lt;/code&gt;&lt;/b&gt; : &lt;b&gt;Default&lt;/b&gt;&lt;div class=&quot;sub-desc&quot;&gt;
		/// {@link #close remove} the window from the DOM and {@link Ext.Component#destroy destroy}
		/// it and all descendant Components. The window will &lt;b&gt;not&lt;/b&gt; be available to be
		/// redisplayed via the {@link #show} method.
		/// &lt;/div&gt;&lt;/li&gt;
		/// &lt;li&gt;&lt;b&gt;&lt;code&gt;&apos;{@link #hide}&apos;&lt;/code&gt;&lt;/b&gt; : &lt;div class=&quot;sub-desc&quot;&gt;
		/// {@link #hide} the window by setting visibility to hidden and applying negative offsets.
		/// The window will be available to be redisplayed via the {@link #show} method.
		/// &lt;/div&gt;&lt;/li&gt;
		/// &lt;/ul&gt;&lt;/div&gt;
		/// &lt;p&gt;&lt;b&gt;Note:&lt;/b&gt; This setting does not affect the {@link #close} method
		/// which will always {@link Ext.Component#destroy destroy} the window. To
		/// programatically &lt;i&gt;hide&lt;/i&gt; a window, call {@link #hide}.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("closeAction")]
		public string CloseAction;
		
		/// <summary>
		/// True to constrain the window within its containing element, false to allow it to fall outside of its
		/// containing element. By default the window will be rendered to document.body. To render and constrain the
		/// window within another element specify {@link #renderTo}.
		/// (defaults to false). Optionally the header only can be constrained using {@link #constrainHeader}.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("constrain")]
		public bool Constrain;
		
		/// <summary>
		/// True to constrain the window header within its containing element (allowing the window body to fall outside
		/// of its containing element) or false to allow the header to fall outside its containing element (defaults to
		/// false). Optionally the entire window can be constrained using {@link #constrain}.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("constrainHeader")]
		public bool ConstrainHeader;
		
		/// <summary>
		/// True to render the window body with a transparent background so that it will blend into the framing
		/// elements, false to add a lighter background color to visually highlight the body element and separate it
		/// more distinctly from the surrounding frame (defaults to false).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("plain")]
		public bool Plain;
		
		/// <summary>
		/// True to display the &apos;minimize&apos; tool button and allow the user to minimize the window, false to hide the button
		/// and disallow minimizing the window (defaults to false). Note that this button provides no implementation --
		/// the behavior of minimizing a window is implementation-specific, so the minimize event must be handled and a
		/// custom minimize behavior implemented for this option to be useful.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("minimizable")]
		public bool Minimizable;
		
		/// <summary>
		/// True to display the &apos;maximize&apos; tool button and allow the user to maximize the window, false to hide the button
		/// and disallow maximizing the window (defaults to false). Note that when a window is maximized, the tool button
		/// will automatically change to a &apos;restore&apos; button with the appropriate behavior already built-in that will
		/// restore the window to its previous size.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("maximizable")]
		public bool Maximizable;
		
		/// <summary>The minimum height in pixels allowed for this window (defaults to 100). Only applies when resizable = true.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("minHeight")]
		public System.Number MinHeight;
		
		/// <summary>The minimum width in pixels allowed for this window (defaults to 200). Only applies when resizable = true.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("minWidth")]
		public System.Number MinWidth;
		
		/// <summary>
		/// True to always expand the window when it is displayed, false to keep it in its current state (which may be
		/// {@link #collapsed}) when displayed (defaults to true).
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("expandOnShow")]
		public bool ExpandOnShow;
		
		/// <summary>
		/// The number of seconds that the window show animation takes if enabled.
		/// Defaults to 0.25
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("showAnimDuration")]
		public System.Number ShowAnimDuration;
		
		/// <summary>
		/// The number of seconds that the window hide animation takes if enabled.
		/// Defaults to 0.25
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("hideAnimDuration")]
		public System.Number HideAnimDuration;
		
		/// <summary>True to hide the window until show() is explicitly called (defaults to true).</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("initHidden")]
		public bool InitHidden;
		
		/// <summary>
		/// Render this component hidden (default is true). If true, the
		/// {@link #hide} method will be called internally.
		/// </summary>
		/// <htmlSummary>
		/// Render this component hidden (default is &lt;tt&gt;true&lt;/tt&gt;). If &lt;tt&gt;true&lt;/tt&gt;, the
		/// {@link #hide} method will be called internally.
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("hidden")]
		public bool Hidden;
		
		/// <summary>@hide</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("elements")]
		public string Elements;
		
		/// <summary>@hide</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("frame")]
		public bool Frame;
		
		/// <summary>@hide</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("floating")]
		public bool Floating;
		
		/// <summary>Fires after the window has been visually activated via {@link #setActive}.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("activateEventName")]
		public const string ActivateEventName = "activate";
		
		/// <summary>Fires after the window has been visually deactivated via {@link #setActive}.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("deactivateEventName")]
		public const string DeactivateEventName = "deactivate";
		
		/// <summary>Fires after the window has been resized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("resizeEventName")]
		public const string ResizeEventName = "resize";
		
		/// <summary>Fires after the window has been maximized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("maximizeEventName")]
		public const string MaximizeEventName = "maximize";
		
		/// <summary>Fires after the window has been minimized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("minimizeEventName")]
		public const string MinimizeEventName = "minimize";
		
		/// <summary>Fires after the window has been restored to its original size after being maximized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("restoreEventName")]
		public const string RestoreEventName = "restore";
		
		/// <summary>@hide</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("autoWidth")]
		public bool AutoWidth;
		#endregion
		
		#region Properties
		/// <summary>
		/// If this Window is configured {@link #draggable}, this property will contain
		/// an instance of {@link Ext.dd.DD} which handles dragging the Window&apos;s DOM Element.  This has implementations of startDrag, onDrag and endDrag
		/// which perform the dragging action. If extra logic is needed at these points, use
		/// {@link Function#createInterceptor createInterceptor} or {@link Function#createSequence createSequence} to
		/// augment the existing implementations.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;If this Window is configured {@link #draggable}, this property will contain
		/// an instance of {@link Ext.dd.DD} which handles dragging the Window&apos;s DOM Element.&lt;/p&gt;
		/// &lt;p&gt;This has implementations of &lt;code&gt;startDrag&lt;/code&gt;, &lt;code&gt;onDrag&lt;/code&gt; and &lt;code&gt;endDrag&lt;/code&gt;
		/// which perform the dragging action. If extra logic is needed at these points, use
		/// {@link Function#createInterceptor createInterceptor} or {@link Function#createSequence createSequence} to
		/// augment the existing implementations.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("dd")]
		[IntrinsicProperty()]
		public ext.dd.DD Dd
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>
		/// Focuses the window. If a defaultButton is set, it will receive focus, otherwise the
		/// window itself will receive focus.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("focus")]
		public void Focus()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Method that is called immediately before the show event is fired.
		/// Defaults to Ext.emptyFn.
		/// </summary>
		/// <htmlSummary>
		/// Method that is called immediately before the &lt;code&gt;show&lt;/code&gt; event is fired.
		/// Defaults to &lt;code&gt;Ext.emptyFn&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("onShow")]
		public void OnShow()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Method that is called immediately before the hide event is fired.
		/// Defaults to Ext.emptyFn.
		/// </summary>
		/// <htmlSummary>
		/// Method that is called immediately before the &lt;code&gt;hide&lt;/code&gt; event is fired.
		/// Defaults to &lt;code&gt;Ext.emptyFn&lt;/code&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("onHide")]
		public void OnHide()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Placeholder method for minimizing the window. By default, this method simply fires the {@link #minimize} event
		/// since the behavior of minimizing a window is application-specific. To implement custom minimize behavior,
		/// either the minimize event can be handled or this method can be overridden.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("minimize")]
		public ext.Window MinimizeMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Closes the Window, removes it from the DOM, {@link Ext.Component#destroy destroy}s
		/// the Window object and all its descendant Components. The {@link Ext.Panel#beforeclose beforeclose}
		/// event is fired before the close happens and will cancel the close action if it returns false.  Note: This method is not affected by the {@link #closeAction} setting which
		/// only affects the action triggered when clicking the {@link #closable &apos;close&apos; tool in the header}.
		/// To hide the Window without destroying it, call {@link #hide}.
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Closes the Window, removes it from the DOM, {@link Ext.Component#destroy destroy}s
		/// the Window object and all its descendant Components. The {@link Ext.Panel#beforeclose beforeclose}
		/// event is fired before the close happens and will cancel the close action if it returns false.&lt;p&gt;
		/// &lt;p&gt;&lt;b&gt;Note:&lt;/b&gt; This method is not affected by the {@link #closeAction} setting which
		/// only affects the action triggered when clicking the {@link #closable &apos;close&apos; tool in the header}.
		/// To hide the Window without destroying it, call {@link #hide}.&lt;/p&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("close")]
		public void Close()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Fits the window within its current container and automatically replaces
		/// the {@link #maximizable &apos;maximize&apos; tool button} with the &apos;restore&apos; tool button.
		/// Also see {@link #toggleMaximize}.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("maximize")]
		public ext.Window MaximizeMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Restores a {@link #maximizable maximized} window back to its original
		/// size and position prior to being maximized and also replaces
		/// the &apos;restore&apos; tool button with the &apos;maximize&apos; tool button.
		/// Also see {@link #toggleMaximize}.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("restore")]
		public ext.Window RestoreMethod()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// A shortcut method for toggling between {@link #maximize} and {@link #restore} based on the current maximized
		/// state of the window.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("toggleMaximize")]
		public ext.Window ToggleMaximize()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Removes any existing anchor from this window. See {@link #anchorTo}.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("clearAnchor")]
		public ext.Window ClearAnchor()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Makes this the active window by showing its shadow, or deactivates it by hiding its shadow. This method also
		/// fires the {@link #activate} or {@link #deactivate} event depending on which action occurred. This method is
		/// called internally by {@link Ext.WindowMgr}.
		/// </summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="active">True to activate the window, false to deactivate it (defaults to false)</param>
		[ScriptName("setActive")]
		public void SetActive(bool active)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sends this window to the back of (lower z-index than) any other visible windows</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("toBack")]
		public ext.Window ToBack()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Centers this window in the viewport</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("center")]
		public ext.Window Center()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the target element from which the window should animate while opening.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="el">The target element or id</param>
		[ScriptName("setAnimateTarget")]
		public void SetAnimateTarget(string el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Sets the target element from which the window should animate while opening.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="el">The target element or id</param>
		[ScriptName("setAnimateTarget")]
		public void SetAnimateTarget(ext.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id from which the window should
		/// animate while opening (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is displayed</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback is executed. Defaults to this Window.</param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show(string animateTarget, System.Delegate callback, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id from which the window should
		/// animate while opening (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is displayed</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback is executed. Defaults to this Window.</param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show(ext.Element animateTarget, System.Delegate callback, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id from which the window should
		/// animate while opening (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is displayed</param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show(string animateTarget, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id from which the window should
		/// animate while opening (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is displayed</param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show(ext.Element animateTarget, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id from which the window should
		/// animate while opening (defaults to null with no animation)
		/// </param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show(string animateTarget)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id from which the window should
		/// animate while opening (defaults to null with no animation)
		/// </param>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show(ext.Element animateTarget)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Shows the window, rendering it first if necessary, or activates it and brings it to front if hidden.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("show")]
		public ext.Window Show()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id to which the window should
		/// animate while hiding (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is hidden</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback is executed. Defaults to this Window.</param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide(string animateTarget, System.Delegate callback, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id to which the window should
		/// animate while hiding (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is hidden</param>
		/// <param name="scope">The scope (<c>this</c> reference) in which the callback is executed. Defaults to this Window.</param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide(ext.Element animateTarget, System.Delegate callback, object scope)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id to which the window should
		/// animate while hiding (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is hidden</param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide(string animateTarget, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id to which the window should
		/// animate while hiding (defaults to null with no animation)
		/// </param>
		/// <param name="callback">A callback function to call after the window is hidden</param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide(ext.Element animateTarget, System.Delegate callback)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id to which the window should
		/// animate while hiding (defaults to null with no animation)
		/// </param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide(string animateTarget)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="animateTarget">
		/// The target element or id to which the window should
		/// animate while hiding (defaults to null with no animation)
		/// </param>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide(ext.Element animateTarget)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Hides the window, setting it to invisible and applying negative offsets.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("hide")]
		public ext.Window Hide()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Aligns the window to the specified element</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to (see {@link Ext.Element#alignTo} for more details).</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <returns>this</returns>
		[ScriptName("alignTo")]
		public ext.Window AlignTo(object element, string position, System.Array offsets)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Aligns the window to the specified element</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">(optional, defaults to &quot;tl-bl?&quot;) The position to align to (see {@link Ext.Element#alignTo} for more details).</param>
		/// <returns>this</returns>
		[ScriptName("alignTo")]
		public ext.Window AlignTo(object element, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors this window to another element and realigns it when the window is resized or scrolled.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to (see {@link Ext.Element#alignTo} for more details)</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="monitorScroll">
		/// true to monitor body scroll and reposition. If this parameter
		/// is a number, it is used as the buffer delay (defaults to 50ms).
		/// </param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Window AnchorTo(object element, string position, System.Array offsets, bool monitorScroll)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors this window to another element and realigns it when the window is resized or scrolled.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to (see {@link Ext.Element#alignTo} for more details)</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <param name="monitorScroll">
		/// true to monitor body scroll and reposition. If this parameter
		/// is a number, it is used as the buffer delay (defaults to 50ms).
		/// </param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Window AnchorTo(object element, string position, System.Array offsets, System.Number monitorScroll)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors this window to another element and realigns it when the window is resized or scrolled.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to (see {@link Ext.Element#alignTo} for more details)</param>
		/// <param name="offsets">Offset the positioning by [x, y]</param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Window AnchorTo(object element, string position, System.Array offsets)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Anchors this window to another element and realigns it when the window is resized or scrolled.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="element">The element to align to.</param>
		/// <param name="position">The position to align to (see {@link Ext.Element#alignTo} for more details)</param>
		/// <returns>this</returns>
		[ScriptName("anchorTo")]
		public ext.Window AnchorTo(object element, string position)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Brings this window to the front of any other visible windows</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <param name="e">Specify &lt;tt&gt;false&lt;/tt&gt; to prevent the window from being focused.</param>
		/// <returns>this</returns>
		[ScriptName("toFront")]
		public ext.Window ToFront(bool e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Brings this window to the front of any other visible windows</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		/// <returns>this</returns>
		[ScriptName("toFront")]
		public ext.Window ToFront()
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
		
		#region Events
		/// <summary>Fires after the window has been visually activated via {@link #setActive}.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("activate")]
		public event ext.auto.Delegate_ext_Window Activate;
		
		/// <summary>Fires after the window has been visually deactivated via {@link #setActive}.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("deactivate")]
		public event ext.auto.Delegate_ext_Window Deactivate;
		
		/// <summary>Fires after the window has been resized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("resize")]
		public event ext.auto.Delegate_ext_Window_And_System_Number_And_System_Number Resize;
		
		/// <summary>Fires after the window has been maximized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("maximize")]
		public event ext.auto.Delegate_ext_Window Maximize;
		
		/// <summary>Fires after the window has been minimized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("minimize")]
		public event ext.auto.Delegate_ext_Window Minimize;
		
		/// <summary>Fires after the window has been restored to its original size after being maximized.</summary>
		/// <definedin>src\widgets\Window.js</definedin>
		[ScriptName("restore")]
		public event ext.auto.Delegate_ext_Window Restore;
		#endregion
	}
}
